﻿#Boa:Frame:Frame1

# -*- coding: utf-8 -*-

'''
# -*- coding: iso-8859-15 -*-
'''

import wx,os,os.path,sys,threading,time,shutil,base64,signal
import gettext, Class_Serv_Ihm,dlg_infos_serveur
from wx.lib.wordwrap import wordwrap
from Class_ABC_XML import XML_ABC
from Class_ABC_Crypt import ABC_Crypt
from subprocess import PIPE
from subprocess import Popen


import commun 
commun.init_langue()

'''
if hasattr(sys,"setdefaultencoding"):
    sys.setdefaultencoding("latin-1")
else:
   pass # site.py did it already for us and everything should work
'''

def create(parent):
    return Frame1(parent)

[wxID_FRAME1, wxID_FRAME1BITMAPBUTTON1, wxID_FRAME1BITMAPBUTTON2, 
 wxID_FRAME1BTN_AJOUTER, wxID_FRAME1BTN_SUPPRIMER, 
 wxID_FRAME1CHB_DESACTIVERSYNCHRO, wxID_FRAME1CHECKLISTBOX1, 
 wxID_FRAME1SPINCTRL1, wxID_FRAME1SPINCTRL2, wxID_FRAME1STATICBOX1, 
 wxID_FRAME1STATICBOX2, wxID_FRAME1STATICBOX3, wxID_FRAME1STATICTEXT1, 
] = [wx.NewId() for _init_ctrls in range(13)]

class DemoTaskBarIcon(wx.TaskBarIcon):
    # --------------------------------------------------------------------------
    # cette classe gere l'icone dans le systray et le  menu clic droit
    # --------------------------------------------------------------------------
    
    TBMENU_SYNCHRO = wx.NewId()
    TBMENU_GESTIONREPS   = wx.NewId()
    TBMENU_AUTH = wx.NewId()
    TBMENU_CONFXML = wx.NewId()
    TBMENU_RESTAURATION = wx.NewId()
    # --- A ENLEVER ---
    TBMENU_QUITTER  = wx.NewId()
    
    # sous menu de sauvegarde/restauration du fichier de configuration
    TBMENU_SAVELOG  = wx.NewId()
    TBMENU_RESTORELOG  = wx.NewId()
    
           
    def __init__(self, frame):
        wx.TaskBarIcon.__init__(self)
        self.frame = frame
        icon = wx.Icon('img/fleche.png', wx.BITMAP_TYPE_PNG)

        self.SetIcon(icon, _("Syncronisation Active"))
                
        self.Bind(wx.EVT_TASKBAR_LEFT_DCLICK, self.OnTaskBarActivate)
        self.Bind(wx.EVT_MENU, self.menuSynchro, id=self.TBMENU_SYNCHRO)
        self.Bind(wx.EVT_MENU, self.menuRestau, id=self.TBMENU_RESTAURATION)
        self.Bind(wx.EVT_MENU, self.menuGestionReps, id=self.TBMENU_GESTIONREPS)
        self.Bind(wx.EVT_MENU, self.save_Conf, id=self.TBMENU_SAVELOG)
        self.Bind(wx.EVT_MENU, self.restore_Conf, id=self.TBMENU_RESTORELOG)
        self.Bind(wx.EVT_MENU, self.regenere_xml, id=self.TBMENU_CONFXML)
        
        # --- A ENLEVER ---
        self.Bind(wx.EVT_MENU, self.menuQuitter, id=self.TBMENU_QUITTER)
        

        
    def __del__(self):
        wx.TaskBarIcon.Destroy()
        
    def CreatePopupMenu(self):
        
        sous_menu_log = wx.Menu()
        sous_menu_log.Append(self.TBMENU_SAVELOG,_(u"Sauvegarder"))
        sous_menu_log.Append(self.TBMENU_RESTORELOG,_(u"Restaurer"))
        sous_menu_secu = wx.Menu()
        sous_menu_secu.Append(self.TBMENU_CONFXML,_(u"Mettre à jour le serveur/groupe"))
        
        
        menu = wx.Menu()
        menu.Append(self.TBMENU_SYNCHRO, _(u"Sauvegarde immédiate"))
        menu.AppendSeparator()
        menu.Append(self.TBMENU_RESTAURATION, _(u"Portail de restauration"))
        menu.AppendSeparator()
        menu.Append(self.TBMENU_GESTIONREPS, _(u"Gestion des répertoires"))

        # sous menu de  sauvegarde/restauration du fichier de conf
        menu.AppendSeparator()
        menu.AppendMenu(-1,_(u"Sécurité"),sous_menu_secu)
        menu.AppendMenu(-1,_("Fichier de configuration"),sous_menu_log)
        menu.AppendSeparator()
        
        # --- A ENLEVER ---
        menu.Append(self.TBMENU_QUITTER, _("Quitter l'application"))
        # --- /A ENLEVER ---
        return menu
        

    def regenere_xml(self,evt):
        self.frame.regenere_ConfXML()
        
    def genauth(self,evt):
        self.frame.regenere_auth()
        
    def save_Conf(self, evt):
        self.frame.save_Conf()
    
    def restore_Conf(self, evt):
        self.frame.restore_Conf()
        
    def OnTaskBarActivate(self, evt):
        self.frame.Affiche_infos()
	
    def menuGestionReps(self, evt):
        self.frame.Affiche_gestion_repertoires()
        
    def menuSynchro(self, evt):
        self.frame.synchro(evt)
        
    def menuRestau(self, evt):
        self.frame.Restau()           
    
    def menuInfos(self, evt):
        self.frame.Affiche_infos()        
    
    def menuAbout(self, evt):
        self.frame.Affiche_about()
        
    def menuAide(self, evt):
        os.startfile('Manuel_d_utilisation.pdf')
        
    def menuLog(self,evt):
        self.frame.affiche_log()        
        
    def menuQuitter(self, evt):
        sys.exit()

    def mac(self, evt):
        self.frame.mac()
        


#---------------------------------------------------------------------------

class MyFileDropTarget(wx.FileDropTarget):
    def __init__(self,parent):
        wx.FileDropTarget.__init__(self)
        self.parent=parent
        
    def OnDropFiles(self, x, y, filenames):

        for file in filenames:
            self.parent.ajouter_rep(file)
#---------------------------------------------------------------------------            
            
class Frame1(wx.Frame):
    def _init_ctrls(self, prnt):
        # generated method, don't edit
        wx.Frame.__init__(self, id=wxID_FRAME1, name='', parent=prnt,
              pos=wx.Point(361, 288), size=wx.Size(737, 410),
              style=wx.DEFAULT_FRAME_STYLE,
              title=_('Gestion de la synchronisation'))
        self.SetClientSize(wx.Size(737, 388))
        self.SetBackgroundColour(wx.Colour(237, 237, 232))
        self.SetBackgroundStyle(wx.BG_STYLE_SYSTEM)
        self.SetToolTipString(u'')
        self.Enable(True)
        self.SetMaxSize(wx.Size(737, 410))
        self.SetMinSize(wx.Size(737, 410))

        self.checkListBox1 = wx.CheckListBox(choices=self.tableau,
              id=wxID_FRAME1CHECKLISTBOX1, name='checkListBox1', parent=self,
              pos=wx.Point(136, 48), size=wx.Size(584, 320), style=0)
        self.checkListBox1.SetBackgroundColour(wx.Colour(255, 255, 255, 255))
        self.checkListBox1.SetToolTipString(_(u'Liste des répertoires en sauvegardes'))
        self.checkListBox1.SetStringSelection(u'')

        self.staticBox1 = wx.StaticBox(id=wxID_FRAME1STATICBOX1,
              label=_(u'Répertoires'), name='staticBox1', parent=self,
              pos=wx.Point(16, 24), size=wx.Size(104, 120), style=0)
        self.staticBox1.SetBackgroundColour(wx.Colour(230, 230, 230))

        self.staticBox2 = wx.StaticBox(id=wxID_FRAME1STATICBOX2,
              label=_('Intervalle'), name='staticBox2', parent=self,
              pos=wx.Point(16, 280), size=wx.Size(104, 96), style=0)

        self.staticBox3 = wx.StaticBox(id=wxID_FRAME1STATICBOX3,
              label=u'Config', name='staticBox3', parent=self, pos=wx.Point(16,
              152), size=wx.Size(104, 120), style=0)
        '''
        self.spinCtrl1 = wx.SpinCtrl(id=wxID_FRAME1SPINCTRL1, initial=120,
              max=420, min=120, name='spinCtrl1', parent=self, pos=wx.Point(32,
              304), size=wx.Size(120, 23), style=wx.NO_3D)
        #self.spinCtrl1.Bind(wx.EVT_SPINCTRL, self.OnSpinCtrl1Spinctrl,
             # id=wxID_FRAME1SPINCTRL1)
        '''
        self.spinCtrl1 = wx.SpinCtrl(self, -1, "", (32, 304))
        self.spinCtrl1.SetRange(15,420)
        self.spinCtrl1.SetValue(120)
        
        
        self.chb_desactiversynchro = wx.CheckBox(id=wxID_FRAME1CHB_DESACTIVERSYNCHRO,
              label=_(u'Désactiver'), name=u'chb_desactiversynchro', parent=self,
              pos=wx.Point(22, 336), size=wx.Size(88, 13), style=0)
        self.chb_desactiversynchro.SetValue(True)
        self.chb_desactiversynchro.SetToolTipString(u'Désactiver la synchronisation automatique')

        self.bitmapButton1 = wx.BitmapButton(bitmap=wx.Bitmap(u'img/appliquer.png',
              wx.BITMAP_TYPE_PNG), id=wxID_FRAME1BITMAPBUTTON1,
              name='bitmapButton1', parent=self, pos=wx.Point(40, 224),
              size=wx.Size(56, 40), style=wx.BU_AUTODRAW)
        self.bitmapButton1.SetToolTipString(_(u'Appliquer'))
        self.bitmapButton1.Bind(wx.EVT_BUTTON, self.OnBtn_appliquerButton,
              id=wxID_FRAME1BITMAPBUTTON1)

        self.bitmapButton2 = wx.BitmapButton(bitmap=wx.Bitmap(u'img/Annuler.png',
              wx.BITMAP_TYPE_PNG), id=wxID_FRAME1BITMAPBUTTON2,
              name='bitmapButton2', parent=self, pos=wx.Point(40, 176),
              size=wx.Size(56, 40), style=wx.BU_AUTODRAW)
        self.bitmapButton2.SetToolTipString(_(u'Annuler'))
        self.bitmapButton2.Bind(wx.EVT_BUTTON, self.OnBtn_annulerButton,
              id=wxID_FRAME1BITMAPBUTTON2)

        self.btn_ajouter = wx.BitmapButton(bitmap=wx.Bitmap(u'img/folder-Add.png',
              wx.BITMAP_TYPE_PNG), id=wxID_FRAME1BTN_AJOUTER,
              name=u'btn_ajouter', parent=self, pos=wx.Point(40, 40),
              size=wx.Size(56, 40), style=wx.BU_AUTODRAW)
        self.btn_ajouter.SetToolTipString(_(u'Ajouter répertoire'))
        self.btn_ajouter.Bind(wx.EVT_BUTTON, self.OnBtn_ajouterButton,
              id=wxID_FRAME1BTN_AJOUTER)

        self.btn_supprimer = wx.BitmapButton(bitmap=wx.Bitmap(u'img/folder-remove.png',
              wx.BITMAP_TYPE_PNG), id=wxID_FRAME1BTN_SUPPRIMER,
              name=u'btn_supprimer', parent=self, pos=wx.Point(40, 88),
              size=wx.Size(56, 40), style=wx.BU_AUTODRAW)
        self.btn_supprimer.SetToolTipString(_(u'Supprimer répertoire'))
        self.btn_supprimer.Bind(wx.EVT_BUTTON, self.OnBtn_supprimerButton,
              id=wxID_FRAME1BTN_SUPPRIMER)

        self.staticText1 = wx.StaticText(id=wxID_FRAME1STATICTEXT1,
              label=(_(u'Gestion des synchronisations')), name='staticText1',
              parent=self, pos=wx.Point(224, 8), size=wx.Size(316, 27),
              style=wx.ALIGN_CENTRE)
        self.staticText1.SetFont(wx.Font(18, wx.SWISS, wx.NORMAL, wx.NORMAL,
              False, u'Arial'))

       

    def __init__(self, parent):
        try:_
        except NameError:
            def _(s):return s
        
        self.parent =  parent
        self.XML = XML_ABC ()
        Path = os.path.expanduser('~')+'/NBS/'
        self.UserName = os.popen('whoami').readline().replace('\n','')
        self.Computername = os.popen('uname -n').readline().replace('\n','')
        self.Conf_Xml = Path+self.UserName+'.xml'

        # repertoire local
        pathname = os.path.dirname(sys.argv[0])
        self.localdir = os.path.abspath(pathname)
  

                
        # --- Une mise a jour a t-elle ete appliquee ? ---
        if os.path.exists('maj.new'):
            self.texte = ''
            for ligne in open('maj.new'):
                self.texte += ligne
            if len(((self.texte.replace('\n','')).replace(' ','')).replace('\t','')) == 0:
                self.texte = _('Une mise a jour a ete effectuee')
            #wx.MessageBox(((texte.rstrip('\n')).lstrip('\n').rstrip(' ')),'Mise ï¿œ jour',style=wx.ICON_INFORMATION|wx.CENTRE)
            boite = dlg_about.dlg_about(self.parent, self, 'maj', self.texte)
            boite.Show()
            
            os.remove('%s/maj.new' % (self.localdir))
        
        
        # --- Initialisations pour les logs ---
        self.Log = ABC_Crypt()
        # ---/ Initialisations pour les logs ---

        # --- recuperation de l'adresse mac (mot de passe ) ---
        #self.mdp = self.adresseMac()
        #self.regenere_XML()
        # --- lecture du nom du groupe depuis le xml ---
        groupe = base64.decodestring(self.XML.Construct_Tab("User","conf/Conf_Rsync.xml")[0])
        
        # --- Verification de l'existance de la cle publique ssh et qu'elle a bien ete envoyee sur le serveur
        self.gen_ssh_keys(groupe)
                
        self.tableau = self.XML.Construct_Tab("dir",self.Conf_Xml)
  
        self.flag_reps = 0
        self.verif_reps(self.tableau,1)
        
        # le tableau temporaire qui contient les s
        self.tabModifications = []
        
        # flag de synchro
        self.flagsync = True
        # nombre de tentatives de synchro au dela desquelles le flagsync sera rï¿œinitialisï¿œ (et rsync killï¿œ)
        self.nberror = 5
        self.Check = 0
        self._init_ctrls(parent)
        
        # --- gestion du drag'n drop ---
        dt= MyFileDropTarget(self)
        self.checkListBox1.SetDropTarget(dt)
        
              
        # recuperation de l'intervalle depuis de fichier de config XML
        self.spinCtrl1.Value = int(self.XML.Construct_Tab("interval",self.Conf_Xml)[0])
        # on stocke la valeur initiale
        self.dureeInitiale = self.spinCtrl1.Value
        
        
        # initialisation de l'icone du systray
        self.tbicon = DemoTaskBarIcon(self)
        #self.tbicon.nettoyage()
        
        # recuperation de la valeur du checkbox de desactivation de la synchro
        if self.XML.Construct_Tab("timeON",self.Conf_Xml)[0] == '1':
            checkbox_value = True; self.change_icone('img/Desactiv.png',_(u'Synchronisation Désactivée')) 
            
        else:
            checkbox_value = False; self.change_icone('img/fleche.png',_(u'Synchronisation Active')) 
            
        self.chb_desactiversynchro.SetValue(checkbox_value)
        
               
        # ce flag sert pour vï¿œrifier que les modifications ont etes validees lorsque on ferme l'IHM
        #  pour eviter des inscriptions erronnees dans le flag.OK
        self.flag_modifications_validees = 0

        # quand on clique sur la croix cela cache seulement la fenetre
        self.Bind(wx.EVT_CLOSE,self.cacher)
        #self.Bind(wx.EVT_CLOSE,self.killprog)
        #self.Bind(wx.EVT_ICONIZE,self.cacher)
        # ï¿œvenement "cocher une ligne" (appelle la mï¿œthode Elements_selectionnes)
        self.Bind(wx.EVT_CHECKLISTBOX, self.Elements_selectionnes, self.checkListBox1)
        
        #liaison des ï¿œvenements timer avec la mï¿œthode de synchro
        self.Bind(wx.EVT_TIMER,self.synchro)
        
        self.timer = wx.Timer(self)
        self.planification()
    '''
    def __del__(self):
        self.t.stop()                                                                                                     
	self.timer.Stop()
    '''

    def regenere_XML(self):
        
        if os.path.isfile('conf/Conf_Rsync.xml'):
            
            pass

        else:
            #Affichage de la boite de dialogue
                        
            groupe=''
            ip_serveur=''
            boite = dlg_infos_serveur.Dialog1(self.parent,str(ip_serveur),str(groupe))
            boite.ShowModal()
        
    def regenere_ConfXML(self):
        # recuperation des infos
            
        groupe = base64.decodestring(self.XML.Construct_Tab("User","conf/Conf_Rsync.xml")[0])
        ip_serveur = self.XML.Construct_Tab("ip",'conf/Conf_Rsync.xml')
 

        #Affichage de la boite de dialogue
        boite = dlg_infos_serveur.Dialog1(self.parent,str(ip_serveur[0]),str(groupe))
        boite.ShowModal()
            
        #Après avoir mis à jour le fichier il faut regenerer les cles ssh
        #self.regenere_auth()
        wx.MessageBox(u"Attention pensez à régénérer votre clef ssh")
        
    def Ping_Serv(self,ip):
        '''Fonction de ping du serveur contenu dans le fichier ini'''
        cmd = 'ping -c 1 %s' % (ip)
        Errno = Popen (cmd,shell = True).wait()
        return Errno       
    
    def regenere_auth(self):
        groupe = base64.decodestring(self.XML.Construct_Tab("User","conf/Conf_Rsync.xml")[0])
        shutil.rmtree(os.path.expanduser('~')+'/.ssh')
        self.gen_ssh_keys(groupe)


    def gen_ssh_keys(self,groupe):
        # recuperation du chemin du profil utilisateur qui lance le programme
        racine = os.path.expanduser('~')
        #le repertoire .ssh existe t-il
        if not os.path.exists(racine+'/.ssh'):
            # si non on le cree
            os.mkdir(racine+'/.ssh')
        
        # la cle publique a t-elle deja ete exportee ? (flag dans le .ssh)
        if not os.path.exists(racine+'/.ssh/flag_export'):
            #la cle publique a t-elle ete generee ?
            if not os.path.exists(racine+'/.ssh/id_dsa.pub'):
                #si non on la genere
                
                #ssh=('ssh-keygen -P \' -f "%(chemin)s/.ssh/id_dsa"\'' % {"chemin":racine})
                gen = 0
                #print ssh
                # si la generation s'est bien passee
                if gen == 0:
                    # --------- envoi de la cle sur le serveur distant  --------- #
                    fichier_conf_sync = 'conf/Conf_Rsync.xml'
                    ip_serveur = self.XML.Construct_Tab("ip",fichier_conf_sync)
                    
                    # on va lire la cle publique
                    contenu_fichier =''
                    #for ligne in open(racine+'/.ssh/id_dsa.pub','r'):
                        #contenu_fichier += ligne
                    
                    
                    #commande_envoi ='ssh %(groupe)s@%(serveur)s "mkdir ~/data 2>/dev/null; mkdir ~/.ssh 2>/dev/null; chmod 700 ~/.ssh; echo "%(cle_pub)s" >> ~/.ssh/authorized_keys; chmod 644 ~/.ssh/authorized_keys"' %  {"groupe":groupe,"serveur":ip_serveur[0],"cle_pub":contenu_fichier}
                    commande_envoi='./ssh.command %(grp)s %(srv)s' % {'grp':groupe,'srv':ip_serveur[0]}
                    envoi = Popen(commande_envoi,shell=True).wait() 
                    #tout s'est bien passe
                    if envoi == 0:
                        #creation du flag indiqunt que la cle publique a ete envoyee
                        flag = open(racine+'/.ssh/flag_export','w')
                        flag.write("envoi ok")
                        flag.close()

    def valeurs_courantes(self):
        '''
        relecture des fichiers de configuration pour recuperer les valeurs courantes de l'intervalle de synchro
        et de la desactivation eventuelle de la planification
        '''
        self.dureeInitiale = int(self.XML.Construct_Tab("interval",self.Conf_Xml)[0])
        #print 'duree_initiale : %s' % (str(self.dureeInitiale))

        if self.XML.Construct_Tab("timeON",self.Conf_Xml)[0] == '1':
            self.checkboxInitial = True
        else:
            self.checkboxInitial = False
        #print 'checkbox_initial : %s' % (str(self.checkboxInitial))     
        
    
    def verif_reps(self,tableau,popup = 1):
        """
        Vï¿œrification que  les  repertoires de la  liste existent toujours
        """
        tableau = self.tableau
        self.tab_erreur =[]
        for path in tableau:
            
            # si chemin est contenu dans un des elements du tableau
            if not os.path.isdir(path):
                
                self.tab_erreur.append(path) 
        
              
  
    def highlight_del_reps(self):
        """
        Mise en evidence des repertoires prï¿œsents dans la liste des synchros mais qui ne sont 
        plus presents sur le disque dur
        """
        # si le tableau est vide, on force la remise de la liste en noir sur blanc 
        if len(self.tab_erreur) ==0:
            self.Retablissement_couleur()
        #self = self.parent
        for ligne in self.tab_erreur:
            self.checkListBox1.SetItemForegroundColour(self.tableau.index(ligne),"RED")
            self.checkListBox1.SetItemBackgroundColour(self.tableau.index(ligne),"BLACK")
        
        # dans tous les cas on rafraichis la checklistbox
        self.checkListBox1.Refresh()
        
        
    def save_Conf(self):
        """
        Sauvegarde du fichier de configuration utililisateur
        """
        
        # fichier de configuration
        self.Conf_Xml = '%(path)s\\NBS\\%(nom)s.xml' % {"path":os.path.expanduser('~'),"nom":os.environ ['USERNAME']} 
        
        # ouverture de la boite de selection de repertoire
        rep_sauvegarde = wx.DirDialog(self.panel,_(u"choisisez le répertoire de sauvegarde"))
        try:
            rep_sauvegarde.ShowModal()
        finally:
            rep_sauvegarde.Destroy()
         
        if  rep_sauvegarde.GetPath()  != '':   
            try:
                shutil.copy(self.Conf_Xml,'%(path)s\\%(nom)s.xml' % {"path":rep_sauvegarde.GetPath(),"nom":os.environ["USERNAME"]})    
                wx.MessageBox(_(u'Fichier sauvegardé'))
            except:wx.MessageBox(_('Erreur lors de la sauvegarde'))    
            
    def restore_Conf(self):
        """
        restauration du fichier de configuration utilisateur
        """
        
        # ouverture  d'une filedialog qui permet d'ouvrir seulement le fichier de  configuration de l'utilisateur courant
        rep_origine = wx.FileDialog(self.panel, message=u"Sélectionnez le fichier à restaurer",
            defaultDir=os.getcwd(), 
            defaultFile="%s.xml" % (os.environ["USERNAME"]),
            wildcard="%(nom)s.xml|%(nom)s.xml" % {"nom":os.environ["USERNAME"]},
            style=wx.OPEN | wx.CHANGE_DIR
            )
        
        # quand on clique sur ok
        if rep_origine.ShowModal() == wx.ID_OK:
            # si le chemin n'est pas vide
            if  rep_origine.GetPath()  != '':
                
                try:
                    # on copie le fichier
                    shutil.copy('%(path)s' % {"path":rep_origine.GetPath()},self.Conf_Xml)    
                    wx.MessageBox(_(u'Fichier restauré\nl\'application va redemarrer'))
                    # on redemarre  l'application pour la prise en compte du nouveau fichier de configuration
                    sys.exit()
                except SystemExit : sys.exit()
                except : wx.MessageBox(_('Erreur lors de la restauration'))    
            
            else: wx.MessageBox(_('Erreur'))

    def mac(self):
        
        
        choix = wx.DirDialog(self)
        try:
            choix.ShowModal()
        finally:
            choix.Destroy()
        
        if choix.GetPath() != '':
            # appel de la fonction de verification des path
            print choix.GetPath()
            cmdmac = "/System/Library/CoreServices/FixupResourceForks \"%(dir)s\"/" % {"dir":choix.GetPath()}
            print cmdmac
            Popen(cmdmac,shell=True).wait()
            #self.ajouter_rep(choix.GetPath())
                

        
     
    def adresseMac(self):
        
        # on lance getmac  et on ï¿œcrit le rï¿œsultat dans un fichier

        Popen('Getmac.exe >> getmac',shell=True).wait()

        # on va ensuite rrecuperer la 4eme ligne et en extraire les 17 premiers caractï¿œres

        texte = []
        for ligne in open('getmac'):
            texte.append(ligne)

        os.remove('%(local)s/getmac' % {'local':self.localdir})
        
        return texte[3][:17]
        
            
        
    def Affiche_infos(self):
        
        """ Affichage de la fenetre d'informations """
        
        #self.affiche_infos()
	self.Affiche_gestion_repertoires()       
               
    def  Restau(self):
        fichier_conf_sync = 'conf/Conf_Rsync.xml'
        ip = self.XML.Construct_Tab("ip",fichier_conf_sync)
        cmd = "firefox http://"+ip[0]+"/NBS/index.php"
        os.popen(cmd)  
        
    def Affiche_about(self):
        """ Affichage de la fenetre "a propos" """
        
        self.affiche_about()
      
    
    def cacher(self,evt):
	    
        if (self.flag_modifications_validees == 1) :

            reponse = wx.MessageDialog(self,_('Des modifications n\'ont pas etes validées\n dans la gestion des répertoires sauvegarder?'),'Question').ShowModal()

            if reponse == wx.ID_OK:

                self.OnBtn_appliquerButton(self)


            else:

                self.OnBtn_annulerButton(self)


        #self.Iconize()
        self.Hide()       

        
    def Affiche_gestion_repertoires(self):
        
        """ Affichage de la fenetre """
        self.verif_reps(self.tableau,0)
        self.Show()
        self.highlight_del_reps()
        
    def affiche_log(self):
            self.affiche_log()
        
        
    def OnBtn_ajouterButton(self, event):
        """ affichage de la fenetre de selection de repertoire """
        
        choix = wx.DirDialog(self)
        try:
            choix.ShowModal()
        finally:
            choix.Destroy()
        
        if choix.GetPath() != '':
            # appel de la fonction de verification des path    
            self.ajouter_rep(choix.GetPath())
                
    def ajouter_rep(self,chemin):
        #self.Retablissement_couleur()
        if self.verifie_path(chemin) == True:
            Mes = "  %(AOO)s :"+chemin+"\n"
            self.Log.LogMes("Ihm.log",Mes)
            self.tableau.append(chemin)
            self.tableau.sort()
            self.rempl_checklistbox(self.tableau)
            self.highlight_del_reps()
            self.flag_modifications_validees = 1

        else:
            pass
                
    def Elements_selectionnes(self, event):
        """ Traitement des elements coches dans la liste """
        
        # recuperation des elements coches dans la liste
        index = event.GetSelection()
        # recuperation des labels associes
        label = self.checkListBox1.GetString(index)
        # si la ligne est cochee
        if self.checkListBox1.IsChecked(index):
            # on ajoute le label de la ligne au tableau des elements a modifier
            self.tabModifications.append(label)
        # sinon cela veut dire qu'on a decoche une case alors on enleve l'element
        #   du tableau apres avoir verifie qu'il y etait 
        elif label in self.tabModifications :
            self.tabModifications.remove(label)
        self.checkListBox1.SetSelection(index)    # moves the highlight
        
    def rempl_checklistbox(self,tab):
        """ Remplissage de la checklistbox """
        #effacement de la liste
        self.checkListBox1.Clear()
        # on parcours le tableau
        for i in tab:
            #remplissage de la checklistbox
            self.checkListBox1.Append(i)

            
    def OnBtn_supprimerButton(self, event):
        """ suppression des elements cochï¿œs """
        # on verifie que des lignes on etes cochees
        if len(self.tabModifications) == 0:
            wx.MessageBox(_(u"Aucune modification, rien n'est coché"))
        else:
            # on parcours le tableau qui contient les elements a supprimer
            for elem in self.tabModifications:
                #  et on supprime les elements
                #Creation du log
                Mes = "   %(BOO)s :"
                #self.Log.LogMes("Ihm.log",Mes)
                self.tableau.remove(elem)
            # reinitialisation du tableau des modifications
            self.tabModifications = []
            #rafraichissement de la checklistbox   
            self.rempl_checklistbox(self.tableau)
            # on met le flag de verification de modifications non validees a 1
            self.flag_modifications_validees = 1


    
    def verifie_path(self,chemin):
        flag = True
        flagmess = 0
        
        # verification du fait qu'on est bien en presence d'un repertoire
        if not os.path.isdir(chemin):
            wx.MessageBox(_(u'%s n\'est pas un répertoire') % (str(chemin)))
            return False
            
        # le chemin est deja dans le tableau
        if chemin in self.tableau:
            wx.MessageBox(_(u'le répertoire %s est deja mis en sauvegarde') % (str(chemin)))
            return False

        for path in self.tableau:
            # ajout d'un backslash a la fin du path sinon 2 repertoires ayant des noms approchant genre test et test2 renverraient une erreur
            path += '\\'
            
            # si chemin est contenu dans un des elements du tableau
            if path.rfind(chemin) != -1:
                index_element = self.tableau.index(path.rstrip('\\'))
                self.checkListBox1.SetItemForegroundColour(index_element,"RED")
                self.checkListBox1.Refresh()
                # choix du message d'erreur
                flagmess = 1
                flag = False
            # si un des elements du tableau est contenu dans le chemin (le rep est deja sauvegarde)
            elif chemin.rfind(path) != -1:
                index_element = self.tableau.index(path.rstrip('\\'))
                self.checkListBox1.SetItemForegroundColour(index_element,"RED")
                self.checkListBox1.Refresh()
                # choix du message d'erreur
                flagmess = 2
                flag = False                
        
        # messages d'erreur
        if flagmess == 1:
            wx.MessageBox(_(u'Au moins un sous repertoire de %s est déja sauvegardé') % (str(chemin)))
        elif flagmess == 2:
            wx.MessageBox(_(u'le répertoire %s est déja sauvegardé') % (str(chemin)))
        else :
            pass
         
        # on renvoie la valeur du flag (True/False)
        return flag

    def OnBtn_appliquerButton(self, event):
        # ecriture du XML avec les modifications
        if self.chb_desactiversynchro.Value == True:
            #Si la coche de desactivation est en place, desactive Synchro passe a 1 et l'icone change
            desactiveSynchro = '1'; self.change_icone('img/Desactiv.png',_(u'Synchronisation Désactivée')) 
        else:
            desactiveSynchro = '0'; self.change_icone('img/fleche.png',_(u'Synchronisation Active')) 
        # print     
        self.XML.Insert_Dir(self.tableau,self.spinCtrl1.Value,desactiveSynchro)
        # message de confirmation pour l'utilisateur
        wx.MessageBox(_(u"Configuration sauvegardée (répertoires)"))
        
        # on met le flag de verification de modifications non validï¿œes a 0
        self.flag_modifications_validees = 0
        

        #Log
        
        Mes = "  %(COO)s \n"
        self.Log.LogMes("Ihm.log",Mes)

        # fermeture de la fenï¿œtre
        self.planification()
        #self.Close()

    def OnBtn_annulerButton(self, event):
        # reinitialisation du tableau en relisant le XML
        self.tableau = suelf.XML.Construct_Tab("dir",self.Conf_Xml)
        wx.MessageBox(_("Modifications annulées (répertoires)"))
        #Log

        Mes = "   %(DOO)s \n"
        self.Log.LogMes("Ihm.log",Mes)
        
        # on met le flag de verification de modifications non validees a 0
        self.flag_modifications_validees = 0
        

        # rafraichissement de l'affichage de la checklistbox
        self.rempl_checklistbox(self.tableau)
        # rï¿œinitialisation du tableau des modifications
        self.tabModifications = []
        #self.Close()
        
    
    def Retablissement_couleur(self):
        # remet la liste en noir 
        
        for i in self.tableau:
            self.checkListBox1.SetItemBackgroundColour(self.tableau.index(i),"WHITE")
            self.checkListBox1.SetItemForegroundColour(self.tableau.index(i),"BLACK")
            self.checkListBox1.Refresh()
    
    
    def modifie_chemin(self, chemin):
        # si un lecteur complet est selectionne
        # on enleve le :\ comme ca cela crera directement un dossier a la lettre du lecteur
        if chemin.endswith(':\\'):
            chemin = chemin.replace(':\\','')  
        else:
            chemin = chemin.replace(':','')
            chemin = chemin.replace('\\','/')
        chemin = '/cygdrive/' + chemin 
        return chemin      
    
    def planification(self):
        if self.timer.IsRunning:
            self.timer.Stop()
        if self.XML.Construct_Tab("timeON",self.Conf_Xml)[0] == '0':
            self.timer.Start(int(self.XML.Construct_Tab("interval",self.Conf_Xml)[0]) * 60000)
        
    def change_icone(self, icone, message):
        
        # Recuperation de l'image de l'icone
        icon = wx.Icon(icone, wx.BITMAP_TYPE_PNG)
        # on cree l'icone
        self.tbicon.SetIcon(icon, message)

    def synchro(self, evt=None):
        self.verif_reps(self.tableau,1)
        t = threading.Thread(target=self.sauvegarde)
        t.start()

    def killprog(self,evt):

        self.cacher()
        #sys.exit()
        
    def sauvegarde(self): 
        Path = os.path.expanduser('~')+'/NBS/'
        fichier_conf_sync = 'conf/Conf_Rsync.xml'
        ip_serveur = self.XML.Construct_Tab("ip",fichier_conf_sync)
        options = self.XML.Construct_Tab("option",fichier_conf_sync)
        groupe = base64.decodestring(self.XML.Construct_Tab("User","conf/Conf_Rsync.xml")[0])
        #Variable qui ecrit l'heure et la date de la derniere sauvegarde
        #Pour la fenetre info
        t = time.localtime(time.time())
        
        if self.Ping_Serv(ip_serveur[0])!=0:
            #wx.MessageBox(_("Le serveur semble injoignable\nVerifiez que votre connexion internet est active."))
            wx.MessageBox(u'Le serveur de sauvegarde semble ne pas répondre, merci de vérifier votre connexion internet', 'Sauvegarde')

            Log = open("usr.log","a")
            st = time.strftime("%d-%B-%Y   %H:%M:%S", t)+'\n'
            Log.write(st)
            message = "Erreur de synchro : connexion internet desactivee \n"
            Log.write(message)
            Log.close()
            Mes ="Erreur de synchro : connexion internet desactivee \n"
            self.Log.LogMes("Ihm.log",Mes)
            
            
        elif self.flagsync == True: # aucune sauvegarde n'est en cours
            
            self.flagsync = False # empechera le lancement d'une autre synchro
                    
            #creation du flag
            flag = open('flag.OK','w')
            # On va ecrire le nom de chaque repertoire dans le flag.OK
            for elem in self.tableau:
                reps = elem.split('/')
                # si le dernier element du tableau est vide c'est qu'un lecteur
                #  entier a ete selectionne, on recupere alors l'element precedent
                if reps[-1] == '':
                    flag.write('%s\n' % (reps[-2].replace(':','')))
                else:
                    flag.write(reps[-1].encode('utf-8') +'\n')
            flag.write('fichier_speciaux')        
            flag.close()
            #/creation du flag
            #-------------------------------------------
            #Ecriture du exclude.rsync
            #-------------------------------------------
            
            self.tableau_exclude = self.XML.Construct_Tab("sfile",self.Conf_Xml)
            exclude = open('exclude.rsync','w')
                          
            if len(self.tableau_exclude) == 0:
                    # si le tableau est vide
                pass
            else:
                for file in self.tableau_exclude:
                    
                    tab_exclude = file.split('\\')
                    nom_file = tab_exclude[-1]
                    exclude.write(nom_file + '\n')
                exclude.close()    
            
            
            '''
            #creation du System.dll
            mdp = open('System.dll','w')
            mdp.write(self.mdp)
            mdp.close()
            #/creation du System.dll
            '''
            
            # creation du tableau de repertoires a synchroniser
            self.tableau = self.XML.Construct_Tab("dir",self.Conf_Xml)
          
            if len(self.tableau) == 0:
                # si le tableau est vide
                pass
            else:
                
                #self.change_icone('img/FlecheRouge.png',_('Synchronisation en cours'))
               
                Horo = Path+'Horo.tmp'
                Lng = []
                for ligne in (open(Horo,'r')):
                    Lng.append(ligne)
                Lang = Lng[1]
                File = open(Horo,"w")
                st = time.strftime("%d-%B-%Y   %H:%M:%S", t)+'\n'
                File.write(st)
                File.write(Lang)
                File.close()
                
              
                for chemin in self.tableau:
                    cmd = "rsync %(option)s --exclude-from=\"exclude.rsync\" -e \"ssh -l %(groupe)s\" \"%(source)s\" %(serveur)s:~/data/%(machine)s-%(user)s" % {"option":options[0],"source":chemin,"machine":self.Computername,"serveur":ip_serveur[0],"user":self.UserName.replace(' ','_'),"groupe":groupe}
                    #print cmd
                    p1 = Popen(cmd,shell=True).wait()
                                        
                    # si tout c'est bien passï¿œ
                    if p1 == 0 :
                        p1 = '   OK'
                    else :
                        Log = open("usr.log","a")
                        p1 = "%("+str(p1)+")s"
                        message = "Erreur de synchro (Rep) : ""  "+ p1 +"\n"
                        Log.write(st)
                        Log.write(message)
                        Log.close()
                        Mes ="   %(FOO)s  "+ p1+"\n"
                        self.Log.LogMes("Ihm.log",Mes)
                    
                   
            cmd_flag = 'rsync %(option)s -e "ssh -l %(groupe)s" "flag.OK" %(serveur)s:~/data/%(machine)s-%(user)s/' % {"option":options[0],"machine":self.Computername,"serveur":ip_serveur[0],"groupe":groupe,"user":self.UserName.replace(' ','_')}
            p2 = Popen(cmd_flag,shell=True).wait()
            
            if p2 == 0 :
                p2 = 'OK'
            else :
                Log = open("usr.log","a")
                p2 = "%("+str(p2)+")s"
                message = "Erreur de synchro (flag) : "+ p2+"\n"
                st = time.strftime("%d-%B-%Y   %H:%M:%S", t)+'\n'
                Log.write(st)
                Log.write(message)
                Log.close()
                Mes = "  %(GOO)s :  %(GAO)s "+ p2+"\n"
                self.Log.LogMes("Ihm.log",Mes)
            
            change_droits = Popen('ssh %(groupe)s@%(serveur)s "chmod 755 -R ~/data/%(machine)s-%(user)s"' %  {"groupe":groupe,"serveur":ip_serveur[0],"machine":self.Computername,"user":self.UserName.replace(' ','_')},shell=True).wait()

            # on change l'icone
            if self.chb_desactiversynchro.Value == True:
                #Si la coche de desactivation est en place, desactive Synchro passe a 1 et l'icone change
                self.change_icone('img/Desactiv.png',_('Synchronisation Desactivee')) 
            else:
                self.change_icone('img/fleche.png',_('Synchronisation Active')) 
                
            # le syncflag repasse a true pour permettre de lancer une autre synchro
            self.flagsync = True
            # rï¿œinitialisation du compteur d'erreur
            self.nberror = 5
            
            
        
                
        elif self.nberror > 0:
            # si le nombre de tentatives de lancement infructueux n'est pas atteint
            ## on affiche le message d'erreur
            wx.MessageBox(_(u'Une synchronisation est déja en cours'))
            ## on dï¿œcrï¿œmente le compteur
            self.nberror -= 1
          
            
        else:
            # quand le nombre est atteint
            ## on coupe le processus rsync (eventuellement)
            #Popen('taskkill /F /IM rsync.exe')
            ## on rï¿œinitialise le compteur
            self.nberror = 5   


        
 
        
